// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef EIGEN_UMFPACKSUPPORT_H
#define EIGEN_UMFPACKSUPPORT_H

// for compatibility with super old version of umfpack,
// not sure this is really needed, but this is harmless.
#ifndef SuiteSparse_long
#ifdef UF_long
#define SuiteSparse_long UF_long
#else
#error neither SuiteSparse_long nor UF_long are defined
#endif
#endif

namespace Eigen {

/* TODO extract L, extract U, compute det, etc... */

// generic double/complex<double> wrapper functions:

// Defaults
inline void
umfpack_defaults(double control[UMFPACK_CONTROL], double, int)
{
	umfpack_di_defaults(control);
}

inline void
umfpack_defaults(double control[UMFPACK_CONTROL], std::complex<double>, int)
{
	umfpack_zi_defaults(control);
}

inline void
umfpack_defaults(double control[UMFPACK_CONTROL], double, SuiteSparse_long)
{
	umfpack_dl_defaults(control);
}

inline void
umfpack_defaults(double control[UMFPACK_CONTROL], std::complex<double>, SuiteSparse_long)
{
	umfpack_zl_defaults(control);
}

// Report info
inline void
umfpack_report_info(double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], double, int)
{
	umfpack_di_report_info(control, info);
}

inline void
umfpack_report_info(double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], std::complex<double>, int)
{
	umfpack_zi_report_info(control, info);
}

inline void
umfpack_report_info(double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], double, SuiteSparse_long)
{
	umfpack_dl_report_info(control, info);
}

inline void
umfpack_report_info(double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], std::complex<double>, SuiteSparse_long)
{
	umfpack_zl_report_info(control, info);
}

// Report status
inline void
umfpack_report_status(double control[UMFPACK_CONTROL], int status, double, int)
{
	umfpack_di_report_status(control, status);
}

inline void
umfpack_report_status(double control[UMFPACK_CONTROL], int status, std::complex<double>, int)
{
	umfpack_zi_report_status(control, status);
}

inline void
umfpack_report_status(double control[UMFPACK_CONTROL], int status, double, SuiteSparse_long)
{
	umfpack_dl_report_status(control, status);
}

inline void
umfpack_report_status(double control[UMFPACK_CONTROL], int status, std::complex<double>, SuiteSparse_long)
{
	umfpack_zl_report_status(control, status);
}

// report control
inline void
umfpack_report_control(double control[UMFPACK_CONTROL], double, int)
{
	umfpack_di_report_control(control);
}

inline void
umfpack_report_control(double control[UMFPACK_CONTROL], std::complex<double>, int)
{
	umfpack_zi_report_control(control);
}

inline void
umfpack_report_control(double control[UMFPACK_CONTROL], double, SuiteSparse_long)
{
	umfpack_dl_report_control(control);
}

inline void
umfpack_report_control(double control[UMFPACK_CONTROL], std::complex<double>, SuiteSparse_long)
{
	umfpack_zl_report_control(control);
}

// Free numeric
inline void
umfpack_free_numeric(void** Numeric, double, int)
{
	umfpack_di_free_numeric(Numeric);
	*Numeric = 0;
}

inline void
umfpack_free_numeric(void** Numeric, std::complex<double>, int)
{
	umfpack_zi_free_numeric(Numeric);
	*Numeric = 0;
}

inline void
umfpack_free_numeric(void** Numeric, double, SuiteSparse_long)
{
	umfpack_dl_free_numeric(Numeric);
	*Numeric = 0;
}

inline void
umfpack_free_numeric(void** Numeric, std::complex<double>, SuiteSparse_long)
{
	umfpack_zl_free_numeric(Numeric);
	*Numeric = 0;
}

// Free symbolic
inline void
umfpack_free_symbolic(void** Symbolic, double, int)
{
	umfpack_di_free_symbolic(Symbolic);
	*Symbolic = 0;
}

inline void
umfpack_free_symbolic(void** Symbolic, std::complex<double>, int)
{
	umfpack_zi_free_symbolic(Symbolic);
	*Symbolic = 0;
}

inline void
umfpack_free_symbolic(void** Symbolic, double, SuiteSparse_long)
{
	umfpack_dl_free_symbolic(Symbolic);
	*Symbolic = 0;
}

inline void
umfpack_free_symbolic(void** Symbolic, std::complex<double>, SuiteSparse_long)
{
	umfpack_zl_free_symbolic(Symbolic);
	*Symbolic = 0;
}

// Symbolic
inline int
umfpack_symbolic(int n_row,
				 int n_col,
				 const int Ap[],
				 const int Ai[],
				 const double Ax[],
				 void** Symbolic,
				 const double Control[UMFPACK_CONTROL],
				 double Info[UMFPACK_INFO])
{
	return umfpack_di_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info);
}

inline int
umfpack_symbolic(int n_row,
				 int n_col,
				 const int Ap[],
				 const int Ai[],
				 const std::complex<double> Ax[],
				 void** Symbolic,
				 const double Control[UMFPACK_CONTROL],
				 double Info[UMFPACK_INFO])
{
	return umfpack_zi_symbolic(n_row, n_col, Ap, Ai, &numext::real_ref(Ax[0]), 0, Symbolic, Control, Info);
}
inline SuiteSparse_long
umfpack_symbolic(SuiteSparse_long n_row,
				 SuiteSparse_long n_col,
				 const SuiteSparse_long Ap[],
				 const SuiteSparse_long Ai[],
				 const double Ax[],
				 void** Symbolic,
				 const double Control[UMFPACK_CONTROL],
				 double Info[UMFPACK_INFO])
{
	return umfpack_dl_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info);
}

inline SuiteSparse_long
umfpack_symbolic(SuiteSparse_long n_row,
				 SuiteSparse_long n_col,
				 const SuiteSparse_long Ap[],
				 const SuiteSparse_long Ai[],
				 const std::complex<double> Ax[],
				 void** Symbolic,
				 const double Control[UMFPACK_CONTROL],
				 double Info[UMFPACK_INFO])
{
	return umfpack_zl_symbolic(n_row, n_col, Ap, Ai, &numext::real_ref(Ax[0]), 0, Symbolic, Control, Info);
}

// Numeric
inline int
umfpack_numeric(const int Ap[],
				const int Ai[],
				const double Ax[],
				void* Symbolic,
				void** Numeric,
				const double Control[UMFPACK_CONTROL],
				double Info[UMFPACK_INFO])
{
	return umfpack_di_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info);
}

inline int
umfpack_numeric(const int Ap[],
				const int Ai[],
				const std::complex<double> Ax[],
				void* Symbolic,
				void** Numeric,
				const double Control[UMFPACK_CONTROL],
				double Info[UMFPACK_INFO])
{
	return umfpack_zi_numeric(Ap, Ai, &numext::real_ref(Ax[0]), 0, Symbolic, Numeric, Control, Info);
}
inline SuiteSparse_long
umfpack_numeric(const SuiteSparse_long Ap[],
				const SuiteSparse_long Ai[],
				const double Ax[],
				void* Symbolic,
				void** Numeric,
				const double Control[UMFPACK_CONTROL],
				double Info[UMFPACK_INFO])
{
	return umfpack_dl_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info);
}

inline SuiteSparse_long
umfpack_numeric(const SuiteSparse_long Ap[],
				const SuiteSparse_long Ai[],
				const std::complex<double> Ax[],
				void* Symbolic,
				void** Numeric,
				const double Control[UMFPACK_CONTROL],
				double Info[UMFPACK_INFO])
{
	return umfpack_zl_numeric(Ap, Ai, &numext::real_ref(Ax[0]), 0, Symbolic, Numeric, Control, Info);
}

// solve
inline int
umfpack_solve(int sys,
			  const int Ap[],
			  const int Ai[],
			  const double Ax[],
			  double X[],
			  const double B[],
			  void* Numeric,
			  const double Control[UMFPACK_CONTROL],
			  double Info[UMFPACK_INFO])
{
	return umfpack_di_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info);
}

inline int
umfpack_solve(int sys,
			  const int Ap[],
			  const int Ai[],
			  const std::complex<double> Ax[],
			  std::complex<double> X[],
			  const std::complex<double> B[],
			  void* Numeric,
			  const double Control[UMFPACK_CONTROL],
			  double Info[UMFPACK_INFO])
{
	return umfpack_zi_solve(sys,
							Ap,
							Ai,
							&numext::real_ref(Ax[0]),
							0,
							&numext::real_ref(X[0]),
							0,
							&numext::real_ref(B[0]),
							0,
							Numeric,
							Control,
							Info);
}

inline SuiteSparse_long
umfpack_solve(int sys,
			  const SuiteSparse_long Ap[],
			  const SuiteSparse_long Ai[],
			  const double Ax[],
			  double X[],
			  const double B[],
			  void* Numeric,
			  const double Control[UMFPACK_CONTROL],
			  double Info[UMFPACK_INFO])
{
	return umfpack_dl_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info);
}

inline SuiteSparse_long
umfpack_solve(int sys,
			  const SuiteSparse_long Ap[],
			  const SuiteSparse_long Ai[],
			  const std::complex<double> Ax[],
			  std::complex<double> X[],
			  const std::complex<double> B[],
			  void* Numeric,
			  const double Control[UMFPACK_CONTROL],
			  double Info[UMFPACK_INFO])
{
	return umfpack_zl_solve(sys,
							Ap,
							Ai,
							&numext::real_ref(Ax[0]),
							0,
							&numext::real_ref(X[0]),
							0,
							&numext::real_ref(B[0]),
							0,
							Numeric,
							Control,
							Info);
}

// Get Lunz
inline int
umfpack_get_lunz(int* lnz, int* unz, int* n_row, int* n_col, int* nz_udiag, void* Numeric, double)
{
	return umfpack_di_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric);
}

inline int
umfpack_get_lunz(int* lnz, int* unz, int* n_row, int* n_col, int* nz_udiag, void* Numeric, std::complex<double>)
{
	return umfpack_zi_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric);
}

inline SuiteSparse_long
umfpack_get_lunz(SuiteSparse_long* lnz,
				 SuiteSparse_long* unz,
				 SuiteSparse_long* n_row,
				 SuiteSparse_long* n_col,
				 SuiteSparse_long* nz_udiag,
				 void* Numeric,
				 double)
{
	return umfpack_dl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric);
}

inline SuiteSparse_long
umfpack_get_lunz(SuiteSparse_long* lnz,
				 SuiteSparse_long* unz,
				 SuiteSparse_long* n_row,
				 SuiteSparse_long* n_col,
				 SuiteSparse_long* nz_udiag,
				 void* Numeric,
				 std::complex<double>)
{
	return umfpack_zl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric);
}

// Get Numeric
inline int
umfpack_get_numeric(int Lp[],
					int Lj[],
					double Lx[],
					int Up[],
					int Ui[],
					double Ux[],
					int P[],
					int Q[],
					double Dx[],
					int* do_recip,
					double Rs[],
					void* Numeric)
{
	return umfpack_di_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric);
}

inline int
umfpack_get_numeric(int Lp[],
					int Lj[],
					std::complex<double> Lx[],
					int Up[],
					int Ui[],
					std::complex<double> Ux[],
					int P[],
					int Q[],
					std::complex<double> Dx[],
					int* do_recip,
					double Rs[],
					void* Numeric)
{
	double& lx0_real = numext::real_ref(Lx[0]);
	double& ux0_real = numext::real_ref(Ux[0]);
	double& dx0_real = numext::real_ref(Dx[0]);
	return umfpack_zi_get_numeric(Lp,
								  Lj,
								  Lx ? &lx0_real : 0,
								  0,
								  Up,
								  Ui,
								  Ux ? &ux0_real : 0,
								  0,
								  P,
								  Q,
								  Dx ? &dx0_real : 0,
								  0,
								  do_recip,
								  Rs,
								  Numeric);
}
inline SuiteSparse_long
umfpack_get_numeric(SuiteSparse_long Lp[],
					SuiteSparse_long Lj[],
					double Lx[],
					SuiteSparse_long Up[],
					SuiteSparse_long Ui[],
					double Ux[],
					SuiteSparse_long P[],
					SuiteSparse_long Q[],
					double Dx[],
					SuiteSparse_long* do_recip,
					double Rs[],
					void* Numeric)
{
	return umfpack_dl_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric);
}

inline SuiteSparse_long
umfpack_get_numeric(SuiteSparse_long Lp[],
					SuiteSparse_long Lj[],
					std::complex<double> Lx[],
					SuiteSparse_long Up[],
					SuiteSparse_long Ui[],
					std::complex<double> Ux[],
					SuiteSparse_long P[],
					SuiteSparse_long Q[],
					std::complex<double> Dx[],
					SuiteSparse_long* do_recip,
					double Rs[],
					void* Numeric)
{
	double& lx0_real = numext::real_ref(Lx[0]);
	double& ux0_real = numext::real_ref(Ux[0]);
	double& dx0_real = numext::real_ref(Dx[0]);
	return umfpack_zl_get_numeric(Lp,
								  Lj,
								  Lx ? &lx0_real : 0,
								  0,
								  Up,
								  Ui,
								  Ux ? &ux0_real : 0,
								  0,
								  P,
								  Q,
								  Dx ? &dx0_real : 0,
								  0,
								  do_recip,
								  Rs,
								  Numeric);
}

// Get Determinant
inline int
umfpack_get_determinant(double* Mx, double* Ex, void* NumericHandle, double User_Info[UMFPACK_INFO], int)
{
	return umfpack_di_get_determinant(Mx, Ex, NumericHandle, User_Info);
}

inline int
umfpack_get_determinant(std::complex<double>* Mx, double* Ex, void* NumericHandle, double User_Info[UMFPACK_INFO], int)
{
	double& mx_real = numext::real_ref(*Mx);
	return umfpack_zi_get_determinant(&mx_real, 0, Ex, NumericHandle, User_Info);
}

inline SuiteSparse_long
umfpack_get_determinant(double* Mx, double* Ex, void* NumericHandle, double User_Info[UMFPACK_INFO], SuiteSparse_long)
{
	return umfpack_dl_get_determinant(Mx, Ex, NumericHandle, User_Info);
}

inline SuiteSparse_long
umfpack_get_determinant(std::complex<double>* Mx,
						double* Ex,
						void* NumericHandle,
						double User_Info[UMFPACK_INFO],
						SuiteSparse_long)
{
	double& mx_real = numext::real_ref(*Mx);
	return umfpack_zl_get_determinant(&mx_real, 0, Ex, NumericHandle, User_Info);
}

/** \ingroup UmfPackSupport_Module
 * \brief A sparse LU factorization and solver based on UmfPack
 *
 * This class allows to solve for A.X = B sparse linear problems via a LU factorization
 * using the UmfPack library. The sparse matrix A must be squared and full rank.
 * The vectors or matrices X and B can be either dense or sparse.
 *
 * \warning The input matrix A should be in a \b compressed and \b column-major form.
 * Otherwise an expensive copy will be made. You can call the inexpensive makeCompressed() to get a compressed matrix.
 * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
 *
 * \implsparsesolverconcept
 *
 * \sa \ref TutorialSparseSolverConcept, class SparseLU
 */
template<typename _MatrixType>
class UmfPackLU : public SparseSolverBase<UmfPackLU<_MatrixType>>
{
  protected:
	typedef SparseSolverBase<UmfPackLU<_MatrixType>> Base;
	using Base::m_isInitialized;

  public:
	using Base::_solve_impl;
	typedef _MatrixType MatrixType;
	typedef typename MatrixType::Scalar Scalar;
	typedef typename MatrixType::RealScalar RealScalar;
	typedef typename MatrixType::StorageIndex StorageIndex;
	typedef Matrix<Scalar, Dynamic, 1> Vector;
	typedef Matrix<int, 1, MatrixType::ColsAtCompileTime> IntRowVectorType;
	typedef Matrix<int, MatrixType::RowsAtCompileTime, 1> IntColVectorType;
	typedef SparseMatrix<Scalar> LUMatrixType;
	typedef SparseMatrix<Scalar, ColMajor, StorageIndex> UmfpackMatrixType;
	typedef Ref<const UmfpackMatrixType, StandardCompressedFormat> UmfpackMatrixRef;
	enum
	{
		ColsAtCompileTime = MatrixType::ColsAtCompileTime,
		MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
	};

  public:
	typedef Array<double, UMFPACK_CONTROL, 1> UmfpackControl;
	typedef Array<double, UMFPACK_INFO, 1> UmfpackInfo;

	UmfPackLU()
		: m_dummy(0, 0)
		, mp_matrix(m_dummy)
	{
		init();
	}

	template<typename InputMatrixType>
	explicit UmfPackLU(const InputMatrixType& matrix)
		: mp_matrix(matrix)
	{
		init();
		compute(matrix);
	}

	~UmfPackLU()
	{
		if (m_symbolic)
			umfpack_free_symbolic(&m_symbolic, Scalar(), StorageIndex());
		if (m_numeric)
			umfpack_free_numeric(&m_numeric, Scalar(), StorageIndex());
	}

	inline Index rows() const { return mp_matrix.rows(); }
	inline Index cols() const { return mp_matrix.cols(); }

	/** \brief Reports whether previous computation was successful.
	 *
	 * \returns \c Success if computation was successful,
	 *          \c NumericalIssue if the matrix.appears to be negative.
	 */
	ComputationInfo info() const
	{
		eigen_assert(m_isInitialized && "Decomposition is not initialized.");
		return m_info;
	}

	inline const LUMatrixType& matrixL() const
	{
		if (m_extractedDataAreDirty)
			extractData();
		return m_l;
	}

	inline const LUMatrixType& matrixU() const
	{
		if (m_extractedDataAreDirty)
			extractData();
		return m_u;
	}

	inline const IntColVectorType& permutationP() const
	{
		if (m_extractedDataAreDirty)
			extractData();
		return m_p;
	}

	inline const IntRowVectorType& permutationQ() const
	{
		if (m_extractedDataAreDirty)
			extractData();
		return m_q;
	}

	/** Computes the sparse Cholesky decomposition of \a matrix
	 *  Note that the matrix should be column-major, and in compressed format for best performance.
	 *  \sa SparseMatrix::makeCompressed().
	 */
	template<typename InputMatrixType>
	void compute(const InputMatrixType& matrix)
	{
		if (m_symbolic)
			umfpack_free_symbolic(&m_symbolic, Scalar(), StorageIndex());
		if (m_numeric)
			umfpack_free_numeric(&m_numeric, Scalar(), StorageIndex());
		grab(matrix.derived());
		analyzePattern_impl();
		factorize_impl();
	}

	/** Performs a symbolic decomposition on the sparcity of \a matrix.
	 *
	 * This function is particularly useful when solving for several problems having the same structure.
	 *
	 * \sa factorize(), compute()
	 */
	template<typename InputMatrixType>
	void analyzePattern(const InputMatrixType& matrix)
	{
		if (m_symbolic)
			umfpack_free_symbolic(&m_symbolic, Scalar(), StorageIndex());
		if (m_numeric)
			umfpack_free_numeric(&m_numeric, Scalar(), StorageIndex());

		grab(matrix.derived());

		analyzePattern_impl();
	}

	/** Provides the return status code returned by UmfPack during the numeric
	 * factorization.
	 *
	 * \sa factorize(), compute()
	 */
	inline int umfpackFactorizeReturncode() const
	{
		eigen_assert(m_numeric && "UmfPackLU: you must first call factorize()");
		return m_fact_errorCode;
	}

	/** Provides access to the control settings array used by UmfPack.
	 *
	 * If this array contains NaN's, the default values are used.
	 *
	 * See UMFPACK documentation for details.
	 */
	inline const UmfpackControl& umfpackControl() const { return m_control; }

	/** Provides access to the control settings array used by UmfPack.
	 *
	 * If this array contains NaN's, the default values are used.
	 *
	 * See UMFPACK documentation for details.
	 */
	inline UmfpackControl& umfpackControl() { return m_control; }

	/** Performs a numeric decomposition of \a matrix
	 *
	 * The given matrix must has the same sparcity than the matrix on which the pattern anylysis has been performed.
	 *
	 * \sa analyzePattern(), compute()
	 */
	template<typename InputMatrixType>
	void factorize(const InputMatrixType& matrix)
	{
		eigen_assert(m_analysisIsOk && "UmfPackLU: you must first call analyzePattern()");
		if (m_numeric)
			umfpack_free_numeric(&m_numeric, Scalar(), StorageIndex());

		grab(matrix.derived());

		factorize_impl();
	}

	/** Prints the current UmfPack control settings.
	 *
	 * \sa umfpackControl()
	 */
	void printUmfpackControl() { umfpack_report_control(m_control.data(), Scalar(), StorageIndex()); }

	/** Prints statistics collected by UmfPack.
	 *
	 * \sa analyzePattern(), compute()
	 */
	void printUmfpackInfo()
	{
		eigen_assert(m_analysisIsOk && "UmfPackLU: you must first call analyzePattern()");
		umfpack_report_info(m_control.data(), m_umfpackInfo.data(), Scalar(), StorageIndex());
	}

	/** Prints the status of the previous factorization operation performed by UmfPack (symbolic or numerical
	 * factorization).
	 *
	 * \sa analyzePattern(), compute()
	 */
	void printUmfpackStatus()
	{
		eigen_assert(m_analysisIsOk && "UmfPackLU: you must first call analyzePattern()");
		umfpack_report_status(m_control.data(), m_fact_errorCode, Scalar(), StorageIndex());
	}

	/** \internal */
	template<typename BDerived, typename XDerived>
	bool _solve_impl(const MatrixBase<BDerived>& b, MatrixBase<XDerived>& x) const;

	Scalar determinant() const;

	void extractData() const;

  protected:
	void init()
	{
		m_info = InvalidInput;
		m_isInitialized = false;
		m_numeric = 0;
		m_symbolic = 0;
		m_extractedDataAreDirty = true;

		umfpack_defaults(m_control.data(), Scalar(), StorageIndex());
	}

	void analyzePattern_impl()
	{
		m_fact_errorCode = umfpack_symbolic(internal::convert_index<StorageIndex>(mp_matrix.rows()),
											internal::convert_index<StorageIndex>(mp_matrix.cols()),
											mp_matrix.outerIndexPtr(),
											mp_matrix.innerIndexPtr(),
											mp_matrix.valuePtr(),
											&m_symbolic,
											m_control.data(),
											m_umfpackInfo.data());

		m_isInitialized = true;
		m_info = m_fact_errorCode ? InvalidInput : Success;
		m_analysisIsOk = true;
		m_factorizationIsOk = false;
		m_extractedDataAreDirty = true;
	}

	void factorize_impl()
	{

		m_fact_errorCode = umfpack_numeric(mp_matrix.outerIndexPtr(),
										   mp_matrix.innerIndexPtr(),
										   mp_matrix.valuePtr(),
										   m_symbolic,
										   &m_numeric,
										   m_control.data(),
										   m_umfpackInfo.data());

		m_info = m_fact_errorCode == UMFPACK_OK ? Success : NumericalIssue;
		m_factorizationIsOk = true;
		m_extractedDataAreDirty = true;
	}

	template<typename MatrixDerived>
	void grab(const EigenBase<MatrixDerived>& A)
	{
		mp_matrix.~UmfpackMatrixRef();
		::new (&mp_matrix) UmfpackMatrixRef(A.derived());
	}

	void grab(const UmfpackMatrixRef& A)
	{
		if (&(A.derived()) != &mp_matrix) {
			mp_matrix.~UmfpackMatrixRef();
			::new (&mp_matrix) UmfpackMatrixRef(A);
		}
	}

	// cached data to reduce reallocation, etc.
	mutable LUMatrixType m_l;
	StorageIndex m_fact_errorCode;
	UmfpackControl m_control;
	mutable UmfpackInfo m_umfpackInfo;

	mutable LUMatrixType m_u;
	mutable IntColVectorType m_p;
	mutable IntRowVectorType m_q;

	UmfpackMatrixType m_dummy;
	UmfpackMatrixRef mp_matrix;

	void* m_numeric;
	void* m_symbolic;

	mutable ComputationInfo m_info;
	int m_factorizationIsOk;
	int m_analysisIsOk;
	mutable bool m_extractedDataAreDirty;

  private:
	UmfPackLU(const UmfPackLU&) {}
};

template<typename MatrixType>
void
UmfPackLU<MatrixType>::extractData() const
{
	if (m_extractedDataAreDirty) {
		// get size of the data
		StorageIndex lnz, unz, rows, cols, nz_udiag;
		umfpack_get_lunz(&lnz, &unz, &rows, &cols, &nz_udiag, m_numeric, Scalar());

		// allocate data
		m_l.resize(rows, (std::min)(rows, cols));
		m_l.resizeNonZeros(lnz);

		m_u.resize((std::min)(rows, cols), cols);
		m_u.resizeNonZeros(unz);

		m_p.resize(rows);
		m_q.resize(cols);

		// extract
		umfpack_get_numeric(m_l.outerIndexPtr(),
							m_l.innerIndexPtr(),
							m_l.valuePtr(),
							m_u.outerIndexPtr(),
							m_u.innerIndexPtr(),
							m_u.valuePtr(),
							m_p.data(),
							m_q.data(),
							0,
							0,
							0,
							m_numeric);

		m_extractedDataAreDirty = false;
	}
}

template<typename MatrixType>
typename UmfPackLU<MatrixType>::Scalar
UmfPackLU<MatrixType>::determinant() const
{
	Scalar det;
	umfpack_get_determinant(&det, 0, m_numeric, 0, StorageIndex());
	return det;
}

template<typename MatrixType>
template<typename BDerived, typename XDerived>
bool
UmfPackLU<MatrixType>::_solve_impl(const MatrixBase<BDerived>& b, MatrixBase<XDerived>& x) const
{
	Index rhsCols = b.cols();
	eigen_assert((BDerived::Flags & RowMajorBit) == 0 && "UmfPackLU backend does not support non col-major rhs yet");
	eigen_assert((XDerived::Flags & RowMajorBit) == 0 && "UmfPackLU backend does not support non col-major result yet");
	eigen_assert(b.derived().data() != x.derived().data() && " Umfpack does not support inplace solve");

	Scalar* x_ptr = 0;
	Matrix<Scalar, Dynamic, 1> x_tmp;
	if (x.innerStride() != 1) {
		x_tmp.resize(x.rows());
		x_ptr = x_tmp.data();
	}
	for (int j = 0; j < rhsCols; ++j) {
		if (x.innerStride() == 1)
			x_ptr = &x.col(j).coeffRef(0);
		StorageIndex errorCode = umfpack_solve(UMFPACK_A,
											   mp_matrix.outerIndexPtr(),
											   mp_matrix.innerIndexPtr(),
											   mp_matrix.valuePtr(),
											   x_ptr,
											   &b.const_cast_derived().col(j).coeffRef(0),
											   m_numeric,
											   m_control.data(),
											   m_umfpackInfo.data());
		if (x.innerStride() != 1)
			x.col(j) = x_tmp;
		if (errorCode != 0)
			return false;
	}

	return true;
}

} // end namespace Eigen

#endif // EIGEN_UMFPACKSUPPORT_H
